home *** CD-ROM | disk | FTP | other *** search
/ Turnbull China Bikeride / Turnbull China Bikeride - Disc 1.iso / ARGONET / PD / GRAPHICS / GIF2RPC.SPK / source / 16bpp_48bit / c / burkes next >
Text File  |  1995-10-16  |  4KB  |  141 lines
  1. /* burkes.c
  2.  * AUTHOR:      Cy Booker, cy@cheepnis.demon.co.uk
  3.  * LICENSE:     FreeWare, Copyright (c) 1995 Cy Booker
  4.  *
  5.  * filter:              *  4  2
  6.  *                1  2  4  2  1         (1/16)
  7.  */
  8.  
  9. #include "internal.h"
  10.  
  11. #include <assert.h>
  12. #include <string.h>             /* memset() */
  13. #include <stdlib.h>             /* calloc() */
  14.  
  15. #include "OS:hourglass.h"
  16. #include "OS:macros.h"
  17.  
  18.  
  19.  
  20. /* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  21.  */
  22.  
  23. extern bool process_gif_16bpp_burkes_48bit(
  24.                 const process_gif       *p) {
  25.   byte                  *rove;
  26.   int                   width, height;
  27.   int                   x, y;
  28.   const os_colour       *palette;
  29.   int                   line_length;
  30.   int                   *buffer, *this_row, *next_row;
  31.   int                   buffer_width;
  32.   int                   red, grn, blu;
  33.   bits                  t;
  34.   int                   error_red, error_grn, error_blu;
  35.   int                   temp_red, temp_grn, temp_blu;
  36.   rgbtupleout           error;
  37.   rgbtupleout_fn        fn;
  38.  
  39.   assert(p);
  40.   assert(p->pixel_width > 0);
  41.   assert(p->pixel_height > 0);
  42.   assert(p->in_palette.colours);
  43.   assert(p->fn);
  44.  
  45.   /*
  46.    * burkes requires storing error info for two pixels to right and two pixels to left
  47.    * so we will just allocate two extra columns for each row and not do any edge checks
  48.    * each entry is stored as {r*SCALE, g*SCALE, b*SCALE}
  49.    */
  50.   buffer_width = (2 + p->pixel_width + 2) * 3;
  51.   buffer = calloc(1, sizeof(*buffer) * (buffer_width * 2));
  52.   if (!buffer) {
  53.     /*
  54.      * oh dear
  55.      */
  56.     return TRUE;
  57.   }
  58.  
  59.   /*
  60.    * note we pre-load values from the process_gif array
  61.    * because it considerably helps the compiler produce better code
  62.    */
  63.   rove = p->buffer;
  64.   width = p->pixel_width;
  65.   height = p->pixel_height;
  66.   palette = p->in_palette.colours;
  67.   line_length = p->line_length;
  68.   fn = p->fn;
  69.   for (y= height; (y > 0); y--) {
  70.     if ((y & 7) == 0) {
  71.       xhourglass_percentage((y * 100) / height);
  72.     }
  73.     this_row = buffer + (buffer_width * ((y + 2) % 2)) + 2*3;
  74.     next_row = buffer + (buffer_width * ((y + 1) % 2)) + 2*3;
  75.     /* bottom row has no errors */
  76.     memset(next_row, 0, sizeof(*next_row) * (buffer_width - 2*3));
  77.     /*
  78.      * note that just because we are actually scanning/outputting right to left
  79.      * doesn't matter as far as burkes is concerned
  80.      * although it might help if we could ``snake''
  81.      */
  82.     for (x= width - 1; (x >= 0); x--) {
  83.       INPUT;
  84.  
  85.       red += *this_row++;                               /* add in errors from all rows */
  86.       grn += *this_row++;
  87.       blu += *this_row++;
  88.  
  89.       PROCESS;
  90.  
  91.       temp_red = (red * 4) / 16; error_red = red - (2 * temp_red);
  92.       temp_grn = (grn * 4) / 16; error_grn = grn - (2 * temp_grn);
  93.       temp_blu = (blu * 4) / 16; error_blu = blu - (2 * temp_blu);
  94.  
  95.       this_row[ 0] += temp_red;                         /* this[ 1] += 4/16 */
  96.       this_row[ 1] += temp_grn;
  97.       this_row[ 2] += temp_blu;
  98.  
  99.       next_row[ 0] += temp_red;                         /* next[ 0] += 4/16 */
  100.       next_row[ 1] += temp_grn;
  101.       next_row[ 2] += temp_blu;
  102.  
  103.       temp_red >>= 1; error_red -= 3 * temp_red;
  104.       temp_grn >>= 1; error_grn -= 3 * temp_grn;
  105.       temp_blu >>= 1; error_blu -= 3 * temp_blu;
  106.  
  107.       this_row[ 3] += temp_red;                         /* this[ 2] += 2/16 */
  108.       this_row[ 4] += temp_grn;
  109.       this_row[ 5] += temp_blu;
  110.  
  111.       next_row[ 3] += temp_red;                         /* next[ 1] += 2/16 */
  112.       next_row[ 4] += temp_grn;
  113.       next_row[ 5] += temp_blu;
  114.  
  115.       next_row[-3] += temp_red;                         /* next[-1] += 2/16 */
  116.       next_row[-2] += temp_grn;
  117.       next_row[-1] += temp_blu;
  118.  
  119.       temp_red += temp_red >> 1; error_red -= temp_red;
  120.       temp_grn += temp_grn >> 1; error_grn -= temp_grn;
  121.       temp_blu += temp_blu >> 1; error_blu -= temp_blu;
  122.  
  123.       next_row[-6] += temp_red;                         /* next[-2] += 1/16 */
  124.       next_row[-5] += temp_grn;
  125.       next_row[-4] += temp_blu;
  126.  
  127.       next_row[ 6] += error_red;                        /* next[ 2] += 1/16 */
  128.       next_row[ 7] += error_grn;
  129.       next_row[ 8] += error_blu;
  130.  
  131.       next_row += 3;                                    /* adjust next_row pointer */
  132.  
  133.     }
  134.     rove += line_length;
  135.   }
  136.   free(buffer);
  137.   return FALSE;
  138. }
  139.  
  140.  
  141.